/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package br.com.tbp.gui.financeiro;

import br.com.tbp.model.domain.financeiro.Lancamento;
import br.com.tbp.model.domain.financeiro.TipoConta;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.swing.table.AbstractTableModel;

/**
 *
 * @author Diego
 */
public class LancamentosTableModel extends AbstractTableModel {

    /* Lista de contas que representam as linhas da tabela*/
    private List<Lancamento> linhas;
    private java.text.DecimalFormat df = new java.text.DecimalFormat("R$ ###,###,##0.00");


    /* Array de Strings com o nome das colunas. */
    private String[] colunas = new String[]{
        "ID lança.", "Data", "Descrição", "Tipo", "Total R$"};


    /* Cria um LancamentosTableModel vazio. */
    public LancamentosTableModel() {
        this.linhas = new ArrayList<Lancamento>();
    }

    /* Cria um LancamentosTableModel carregado com
     * a lista de contas especificada. */
    public LancamentosTableModel(List<Lancamento> linhas) {
        this.linhas = linhas;
    }

    /* Retorna a quantidade de linhas. */
    public int getRowCount() {
        return linhas.size();
    }

    /* Retorna a quantidade de colunas. */
    @Override
    public int getColumnCount() {
        return colunas.length;
    }

    /* Retorna a classe dos elementos da coluna especificada.
     * Este método é usado pela JTable na hora de definir o editor da célula. */
    @Override
    public Class<?> getColumnClass(int columnIndex) {
        switch (columnIndex) {
            case 0:
                return Long.class;
            case 1:
                return Date.class;
            case 2:
                return String.class;
            case 3:
                return TipoConta.class;
            case 4:
                return String.class;
            default:
                throw new IndexOutOfBoundsException("columnIndex out of bounds");
        }
    }

    /* Retorna o nome da coluna no índice especificado.
     * Este método é usado pela JTable para saber o texto do cabeçalho. */
    @Override
    public String getColumnName(int columnIndex) {
        return colunas[columnIndex];
    }

    /* Retorna o valor da célula especificada
     * pelos índices da linha e da coluna. */
    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        // Pega a conta da linha especificada.
        Lancamento lc = this.getLancamento(rowIndex);

        switch (columnIndex) {
            case 0:
                return lc.getId();
            case 1:
                return lc.getData().getTime();
            case 2:
                return lc.getDescricao();
            case 3:
                return lc.getTipo();
            case 4:
                return df.format(lc.getTotal().doubleValue());
            default:
                throw new IndexOutOfBoundsException("columnIndex out of bounds");
        }
    }

    public Lancamento getLancamento(int row) {
        if (row >= 0) {
            return linhas.get(row);
        }
        return null;
    }

    /* Retorna um valor booleano que define se a célula em questão
     * pode ser editada ou não.
     * Este método é utilizado pela JTable na hora de definir o editor da célula.
     * Neste caso, estará sempre retornando false, não permitindo que nenhuma
     * célula seja editada. */
    @Override
    public boolean isCellEditable(int rowIndex, int columnIndex) {
        return false;
    }

    /* Adiciona um registro. */
    public void addLancamento(Lancamento lc) {
        // Adiciona o registro.
        linhas.add(lc);

        // Pega a quantidade de registros e subtrai um para achar
        // o último índice. É preciso subtrair um, pois os índices
        // começam pelo zero.
        int ultimoIndice = getRowCount() - 1;

        // Reporta a mudança. O JTable recebe a notificação
        // e se redesenha permitindo que visualizemos a atualização.
        fireTableRowsInserted(ultimoIndice, ultimoIndice);
    }

    /* Remove a linha especificada. */
    public void excluiLancamento(int indiceLinha) {
        // Remove o sócio da linha especificada.
        linhas.remove(indiceLinha);

        // Reporta a mudança. O JTable recebe a notificação
        // e se redesenha permitindo que visualizemos a atualização.
        fireTableRowsDeleted(indiceLinha, indiceLinha);
    }
}
